/**
 * DevOps BI 埋点脚本 - 优化版
 * 
 * 使用方法:
 * <script async src="https://your-server.com/tracking/script.js" data-tracking-id="YOUR_TRACKING_ID"></script>
 */
(function() {
  // 配置
  var trackingId = '';
  var apiUrl = ''; // 将在初始化时设置
  var sessionId = '';
  var debug = false;
  
  // 性能优化配置
  var config = {
    minInterval: 30000, // 最小跟踪间隔：30秒
    maxRequestsPerMinute: 10, // 每分钟最大请求数
    debounceDelay: 1000, // 防抖延迟：1秒
    enableSPATracking: false, // 默认关闭SPA路由跟踪
    enableScrollTracking: false, // 默认关闭滚动跟踪
    enableClickTracking: false, // 默认关闭点击跟踪
    enableAutoTracking: false, // 默认关闭无侵入式自动跟踪
    enableBatchSend: false, // 默认关闭批量发送
    enableVueSupport: false, // 默认关闭Vue框架支持
    batchSize: 5, // 批量发送大小
    batchTimeout: 5000, // 批量发送超时：5秒
    // 智能降级配置
    preferMethod: 'auto', // 'auto', 'image', 'fetch', 'beacon'
    useBeaconOnUnload: true // 页面卸载时使用Beacon
  };
  
  // 跟踪状态管理
  var trackingState = {
    lastTrackTime: 0,
    requestCount: 0,
    requestResetTime: Date.now(),
    pendingData: [],
    batchTimer: null,
    isInitialized: false,
    lastUrl: window.location.href,
    mutationObserver: null,
    trackedElements: new Set(), // 已绑定埋点的元素集合
    requestCache: {} // 请求去重缓存
  };
  
  // 初始化函数
  function init() {
    // 获取当前脚本标签
    var scripts = document.getElementsByTagName('script');
    var currentScript = scripts[scripts.length - 1];
    
    // 获取跟踪ID
    trackingId = currentScript.getAttribute('data-tracking-id');
    if (!trackingId) {
      log('错误: 未设置 data-tracking-id 属性');
      return;
    }
    
    // 获取API URL
    apiUrl = currentScript.getAttribute('data-api-url');
    if (!apiUrl) {
      // 从脚本src中提取基础URL
      var scriptSrc = currentScript.src;
      var urlParts = scriptSrc.split('/');
      // 移除最后的 "script.js" 和 "tracking"
      urlParts.pop(); // 移除 "script.js"
      var pathSegment = urlParts.pop(); // 移除 "tracking"
      
      // 如果确实是从 /tracking/script.js 加载的
      if (pathSegment === 'tracking') {
        apiUrl = urlParts.join('/');
      } else {
        // 如果路径结构不同，则回退到当前域名
        apiUrl = window.location.origin;
        // 将移除的部分放回去
        urlParts.push(pathSegment);
        apiUrl = urlParts.join('/');
      }
    }
    
    // 确保apiUrl以斜杠结尾
    if (apiUrl && !apiUrl.endsWith('/')) {
      apiUrl += '/';
    }
    
    // 检查是否启用调试
    debug = currentScript.getAttribute('data-debug') === 'true';
    
    // 获取性能配置
    var minInterval = currentScript.getAttribute('data-min-interval');
    if (minInterval) config.minInterval = parseInt(minInterval);
    
    var enableSPA = currentScript.getAttribute('data-enable-spa');
    if (enableSPA) config.enableSPATracking = enableSPA === 'true';
    
    var enableAuto = currentScript.getAttribute('data-enable-auto');
    if (enableAuto) config.enableAutoTracking = enableAuto === 'true';
    
    var enableBatch = currentScript.getAttribute('data-enable-batch');
    if (enableBatch) config.enableBatchSend = enableBatch === 'true';
    
    var enableVue = currentScript.getAttribute('data-enable-vue');
    if (enableVue) config.enableVueSupport = enableVue === 'true';
    
    // 生成或获取会话ID
    sessionId = getSessionId();
    
    log('初始化完成，跟踪ID: ' + trackingId);
    log('API URL: ' + apiUrl);
    log('性能配置: ' + JSON.stringify(config));

    // 记录脚本加载成功
    log('脚本加载成功，开始跟踪页面访问');

    // 只在页面首次加载时跟踪
    trackPageView();

    // 可选：监听历史状态变化（SPA应用）
    if (config.enableSPATracking) {
      setupHistoryChangeListener();
    }
    
    // 可选：启用无侵入式自动跟踪
    if (config.enableAutoTracking) {
      setupAutoTracking();
    }
    
    // 可选：启用Vue框架支持
    if (config.enableVueSupport) {
      setupVueSupport();
    }
    
    // 标记为已初始化
    trackingState.isInitialized = true;
    
    // 发送脚本加载通知到服务器（可选）
    try {
      var loadData = {
        trackingId: trackingId,
        url: window.location.href,
        title: document.title,
        sessionId: sessionId,
        customData: {
          event: 'script_loaded',
          scriptVersion: '2.0.0',
          timestamp: new Date().toISOString()
        }
      };
      
      var loadEndpoint = apiUrl + 'tracking/script-loaded';
      var loadImg = new Image();
      loadImg.src = loadEndpoint + '?' + serialize(loadData) + '&t=' + new Date().getTime();
      loadImg.style.display = 'none';
      document.body.appendChild(loadImg);
    } catch (e) {
      log('脚本加载通知发送失败: ' + e.message);
    }
  }
  
  // 获取或生成会话ID
  function getSessionId() {
    var id = localStorage.getItem('devops_bi_session_id');
    if (!id) {
      id = generateUUID();
      localStorage.setItem('devops_bi_session_id', id);
      
      // 会话24小时后过期
      setTimeout(function() {
        localStorage.removeItem('devops_bi_session_id');
      }, 24 * 60 * 60 * 1000);
    }
    return id;
  }
  
  // 生成UUID
  function generateUUID() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }

  // 简单解析浏览器 / 操作系统 / 设备类型
  function getClientInfo() {
    var ua = navigator.userAgent || '';

    var browser = '';
    if (ua.indexOf('Edg') > -1) browser = 'Edge';
    else if (ua.indexOf('Chrome') > -1) browser = 'Chrome';
    else if (ua.indexOf('Safari') > -1 && ua.indexOf('Chrome') === -1) browser = 'Safari';
    else if (ua.indexOf('Firefox') > -1) browser = 'Firefox';
    else browser = 'Other';

    var os = '';
    if (ua.indexOf('Windows') > -1) os = 'Windows';
    else if (ua.indexOf('Mac OS X') > -1) os = 'macOS';
    else if (ua.indexOf('Android') > -1) os = 'Android';
    else if (ua.indexOf('iPhone') > -1 || ua.indexOf('iPad') > -1) os = 'iOS';
    else os = 'Other';

    var device = 'Desktop';
    if (/Mobi|Android/i.test(ua)) device = 'Mobile';
    if (/iPad|Tablet/i.test(ua)) device = 'Tablet';

    return {
      browser: browser,
      os: os,
      device: device
    };
  }
  
  // 检查是否可以跟踪（频率限制）
  function canTrack() {
    var now = Date.now();
    
    // 检查最小间隔
    if (now - trackingState.lastTrackTime < config.minInterval) {
      log('跟踪频率限制：距离上次跟踪时间过短');
      return false;
    }
    
    // 检查每分钟请求数限制
    if (now - trackingState.requestResetTime > 60000) {
      trackingState.requestCount = 0;
      trackingState.requestResetTime = now;
    }
    
    if (trackingState.requestCount >= config.maxRequestsPerMinute) {
      log('跟踪频率限制：每分钟请求数已达上限');
      return false;
    }
    
    return true;
  }
  
  // 跟踪页面访问 - 优化版（支持智能降级）
  function trackPageView(customData, options) {
    options = options || {};
    
    // 检查频率限制（可跳过）
    if (!options.skipFrequencyCheck && !canTrack()) {
      return;
    }
    
    var previousUrl = trackingState.lastUrl;
    var currentUrl = window.location.href;
    var isRouteChange = previousUrl !== currentUrl && previousUrl !== '';

    var clientInfo = getClientInfo();
    
    var data = {
      trackingId: trackingId,
      url: currentUrl,
      title: document.title,
      referrer: document.referrer || previousUrl,
      sessionId: sessionId,
      customData: extendObject({
        screenWidth: window.innerWidth,
        screenHeight: window.innerHeight,
        language: navigator.language,
        browser: clientInfo.browser,
        os: clientInfo.os,
        device: clientInfo.device,
        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
        timestamp: new Date().toISOString(),
        routeChange: isRouteChange,
        previousUrl: isRouteChange ? previousUrl : undefined
      }, customData || {})
    };
    
    log('跟踪页面访问: ' + data.url + (isRouteChange ? ' (路由变化)' : ''));
    
    // 更新跟踪状态
    trackingState.lastTrackTime = Date.now();
    trackingState.requestCount++;
    trackingState.lastUrl = currentUrl;
    
    // 使用智能降级发送
    return sendData(data, options.method, options);
  }
  
  // 防抖版本的跟踪函数
  var debouncedTrackPageView = debounce(trackPageView, config.debounceDelay);
  
  // 防抖函数
  function debounce(func, wait) {
    var timeout;
    return function executedFunction() {
      var later = function() {
        clearTimeout(timeout);
        func.apply(this, arguments);
      };
      clearTimeout(timeout);
      timeout = setTimeout(later, wait);
    };
  }
  
  
  // 监听历史状态变化（SPA应用）- 优化版
  function setupHistoryChangeListener() {
    // 保存原始方法
    var originalPushState = history.pushState;
    var originalReplaceState = history.replaceState;
    
    // 重写pushState
    history.pushState = function() {
      originalPushState.apply(this, arguments);
      handleUrlChange();
    };
    
    // 重写replaceState
    history.replaceState = function() {
      originalReplaceState.apply(this, arguments);
      handleUrlChange();
    };
    
    // 监听popstate事件
    window.addEventListener('popstate', function() {
      handleUrlChange();
    });
    
    function handleUrlChange() {
      // 使用防抖版本，避免频繁跟踪
      debouncedTrackPageView({
        routeChange: true,
        changeSource: 'history'
      });
    }
  }
  
  // 序列化对象为查询字符串
  function serialize(obj) {
    var str = [];
    for (var p in obj) {
      if (obj.hasOwnProperty(p)) {
        if (typeof obj[p] === 'object') {
          str.push(encodeURIComponent(p) + "=" + encodeURIComponent(JSON.stringify(obj[p])));
        } else {
          str.push(encodeURIComponent(p) + "=" + encodeURIComponent(obj[p]));
        }
      }
    }
    return str.join("&");
  }
  
  // 日志函数
  function log(message) {
    if (debug) {
      console.log('[DevOps BI]', message);
    }
  }
  
  // 发送数据的通用函数 - 支持智能降级
  function sendData(data, method, options) {
    if (!apiUrl) {
      log('错误: API地址未设置');
      return false;
    }
    
    options = options || {};
    method = method || config.preferMethod;
    
    var endpoint = apiUrl + 'tracking/pageview';
    var success = false;
    
    // 请求去重检查
    if (options.skipDedup !== true) {
      var requestKey = generateRequestKey(data);
      if (trackingState.requestCache[requestKey]) {
        log('请求已发送，跳过重复请求');
        return false;
      }
      trackingState.requestCache[requestKey] = true;
      // 1分钟后清理缓存
      setTimeout(function() {
        delete trackingState.requestCache[requestKey];
      }, 60000);
    }
    
    // 批量发送模式
    if (config.enableBatchSend && !options.forceImmediate) {
      addToBatch(data);
      return true;
    }
    
    // 智能降级策略
    if (method === 'auto') {
      // 页面卸载时优先使用Beacon
      if (options.useBeacon && navigator.sendBeacon) {
        return sendWithBeacon(endpoint, data);
      }
      // 尝试Fetch（支持CORS时）
      if (typeof fetch !== 'undefined') {
        return sendWithFetch(endpoint, data, options);
      }
      // 降级到Image
      return sendWithImage(endpoint, data);
    }
    
    // 指定方式发送
    if (method === 'fetch' && typeof fetch !== 'undefined') {
      return sendWithFetch(endpoint, data, options);
    } else if (method === 'beacon' && navigator.sendBeacon) {
      return sendWithBeacon(endpoint, data);
    } else {
      return sendWithImage(endpoint, data);
    }
  }
  
  // 使用Fetch API发送
  function sendWithFetch(endpoint, data, options) {
    var success = false;
    fetch(endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data),
      // 请求超时控制
      signal: options && options.signal || (typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined)
    }).then(function(response) {
      if (response.ok) {
        log('Fetch API 发送成功');
        success = true;
      } else {
        log('Fetch API 发送失败: ' + response.status);
        // 降级到Image方式
        if (config.preferMethod === 'auto') {
          sendWithImage(endpoint, data);
        }
      }
    }).catch(function(error) {
      log('Fetch API 错误: ' + error.message);
      // 降级到Image方式
      if (config.preferMethod === 'auto') {
        sendWithImage(endpoint, data);
      }
    });
    return success;
  }
  
  // 使用SendBeacon API发送
  function sendWithBeacon(endpoint, data) {
    var formData = new FormData();
    Object.keys(data).forEach(function(key) {
      if (typeof data[key] === 'object') {
        formData.append(key, JSON.stringify(data[key]));
      } else {
        formData.append(key, data[key]);
      }
    });
    
    var success = navigator.sendBeacon(endpoint, formData);
    log('SendBeacon 发送结果: ' + success);
    return success;
  }
  
  // 使用Image方式发送（兜底方案）
  function sendWithImage(endpoint, data) {
    var img = new Image();
    var queryString = serialize(data) + '&t=' + new Date().getTime();
    img.src = endpoint + '?' + queryString;
    img.style.display = 'none';
    var success = false;
    
    img.onload = function() {
      log('Image 方式发送成功');
      success = true;
      // 清理临时图片
      if (img.parentNode) {
        img.parentNode.removeChild(img);
      }
    };
    
    img.onerror = function() {
      log('Image 方式发送失败');
      // 可以加入失败队列
      if (config.enableBatchSend) {
        addToFailedQueue(data);
      }
    };
    
    if (document.body) {
      document.body.appendChild(img);
    }
    
    return success;
  }
  
  // 生成请求唯一键（用于去重）
  function generateRequestKey(data) {
    return data.trackingId + '-' + data.url + '-' + data.sessionId + '-' + Math.floor(Date.now() / 60000);
  }
  
  // 批量发送机制
  function addToBatch(data) {
    trackingState.pendingData.push(data);
    
    // 达到批量大小时立即发送
    if (trackingState.pendingData.length >= config.batchSize) {
      flushBatch();
      return;
    }
    
    // 设置定时器，超时自动发送
    if (!trackingState.batchTimer) {
      trackingState.batchTimer = setTimeout(function() {
        flushBatch();
      }, config.batchTimeout);
    }
  }
  
  // 发送批量数据
  function flushBatch() {
    if (trackingState.pendingData.length === 0) {
      return;
    }
    
    var batch = trackingState.pendingData.splice(0);
    clearTimeout(trackingState.batchTimer);
    trackingState.batchTimer = null;
    
    log('批量发送 ' + batch.length + ' 条数据');
    
    // 使用Fetch发送批量数据（支持大数据量）
    if (typeof fetch !== 'undefined') {
      sendWithFetch(apiUrl + 'tracking/pageview', {
        batch: batch,
        count: batch.length,
        trackingId: trackingId,
        sessionId: sessionId
      }, { forceImmediate: true, skipDedup: true });
    } else {
      // 降级：逐条发送
      batch.forEach(function(data) {
        sendWithImage(apiUrl + 'tracking/pageview', data);
      });
    }
  }
  
  // 失败队列（可选）
  var failedQueue = [];
  function addToFailedQueue(data) {
    failedQueue.push(data);
    // 可以设置重试机制
    log('数据已加入失败队列，队列长度: ' + failedQueue.length);
  }
  
  // 对象扩展函数（兼容IE）
  function extendObject(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      if (source) {
        for (var key in source) {
          if (source.hasOwnProperty(key)) {
            target[key] = source[key];
          }
        }
      }
    }
    return target;
  }
  
  // ==================== 无侵入式埋点功能 ====================
  
  // 设置无侵入式自动跟踪
  function setupAutoTracking() {
    log('启用无侵入式自动跟踪');
    
    // 事件委托：全局事件监听
    setupEventDelegation();
    
    // MutationObserver：监听DOM变化
    setupMutationObserver();
    
    // 初始扫描：绑定已有元素
    scanAndBindTrackingElements();
  }
  
  // 事件委托机制
  function setupEventDelegation() {
    // 点击事件
    document.addEventListener('click', function(event) {
      handleAutoTrackEvent(event, 'click');
    }, true);
    
    // 表单提交
    document.addEventListener('submit', function(event) {
      handleAutoTrackEvent(event, 'submit');
    }, true);
    
    // 输入失焦
    document.addEventListener('blur', function(event) {
      handleAutoTrackEvent(event, 'blur');
    }, true);
    
    // 文件选择
    document.addEventListener('change', function(event) {
      if (event.target.type === 'file') {
        handleAutoTrackEvent(event, 'change');
      }
    }, true);
  }
  
  // 处理自动跟踪事件
  function handleAutoTrackEvent(event, eventType) {
    var element = event.target;
    var trackData = parseTrackingAttributes(element, eventType);
    
    if (trackData) {
      log('自动跟踪事件: ' + eventType + ' on ' + trackData.category + '/' + trackData.action);
      
      // 调用公开API进行追踪
      if (window.DevOpsBITracker && window.DevOpsBITracker.trackEvent) {
        window.DevOpsBITracker.trackEvent(
          trackData.category,
          trackData.action,
          trackData.label,
          trackData.value,
          {
            eventType: eventType,
            elementTag: element.tagName,
            elementId: element.id,
            elementClass: element.className,
            elementText: element.textContent ? element.textContent.substring(0, 50) : '',
            elementHref: element.href || '',
            // 文件上传额外信息
            fileInfo: event.target.files && event.target.files[0] ? {
              fileName: event.target.files[0].name,
              fileSize: event.target.files[0].size,
              fileType: event.target.files[0].type
            } : undefined
          }
        );
      }
    }
  }
  
  // 解析元素上的跟踪属性
  function parseTrackingAttributes(element, eventType) {
    // 检查是否有 data-track 属性
    var trackAttr = element.getAttribute('data-track');
    if (!trackAttr) {
      // 检查是否有 data-track-{eventType} 属性
      trackAttr = element.getAttribute('data-track-' + eventType);
      if (!trackAttr) {
        return null;
      }
    }
    
    // 检查是否匹配当前事件类型
    if (trackAttr !== eventType && trackAttr !== 'true' && trackAttr.indexOf(eventType) === -1) {
      return null;
    }
    
    // 解析跟踪数据
    var trackData = {
      category: element.getAttribute('data-track-category') || 'interaction',
      action: element.getAttribute('data-track-action') || eventType,
      label: element.getAttribute('data-track-label') || '',
      value: element.getAttribute('data-track-value') || ''
    };
    
    return trackData;
  }
  
  // MutationObserver：监听DOM变化
  function setupMutationObserver() {
    if (typeof MutationObserver === 'undefined') {
      log('MutationObserver不支持，使用降级方案');
      return;
    }
    
    trackingState.mutationObserver = new MutationObserver(function(mutations) {
      mutations.forEach(function(mutation) {
        mutation.addedNodes.forEach(function(node) {
          if (node.nodeType === 1) { // Element节点
            // 为新元素绑定埋点
            bindTrackingForElement(node);
          }
        });
      });
    });
    
    // 监听整个body的变化
    if (document.body) {
      trackingState.mutationObserver.observe(document.body, {
        childList: true,
        subtree: true
      });
      log('MutationObserver已启动');
    }
  }
  
  // 为元素绑定埋点
  function bindTrackingForElement(element) {
    // 避免重复绑定
    if (trackingState.trackedElements.has(element)) {
      return;
    }
    
    // 检查是否需要绑定
    if (element.hasAttribute('data-track')) {
      trackingState.trackedElements.add(element);
      log('为元素绑定埋点: ' + element.tagName);
    }
    
    // 递归处理子元素
    var children = element.querySelectorAll('[data-track]');
    for (var i = 0; i < children.length; i++) {
      var child = children[i];
      if (!trackingState.trackedElements.has(child)) {
        trackingState.trackedElements.add(child);
      }
    }
  }
  
  // 扫描并绑定已有元素
  function scanAndBindTrackingElements() {
    var elements = document.querySelectorAll('[data-track]');
    for (var i = 0; i < elements.length; i++) {
      bindTrackingForElement(elements[i]);
    }
    log('扫描完成，找到 ' + elements.length + ' 个埋点元素');
  }
  
  // ==================== Vue框架支持 ====================
  
  // 设置Vue框架支持
  function setupVueSupport() {
    log('启用Vue框架支持');
    
    // 检测Vue是否存在
    if (typeof window.Vue !== 'undefined') {
      setupVue2Support();
    } else if (typeof window.Vue !== 'undefined' && window.Vue.version && window.Vue.version.startsWith('3')) {
      setupVue3Support();
    } else {
      log('未检测到Vue框架');
    }
    
    // 检测ElementUI
    if (typeof window.ELEMENT !== 'undefined') {
      setupElementUISupport();
    }
  }
  
  // Vue 2.x 支持
  function setupVue2Support() {
    var Vue = window.Vue;
    
    // 添加全局方法
    Vue.prototype.$track = function(category, action, label, value, customData) {
      if (window.DevOpsBITracker && window.DevOpsBITracker.trackEvent) {
        window.DevOpsBITracker.trackEvent(category, action, label, value, customData);
      }
    };
    
    // 全局混入，自动追踪组件生命周期
    Vue.mixin({
      mounted: function() {
        if (this.$options.tracking) {
          var trackingOpts = this.$options.tracking;
          if (trackingOpts.onMount) {
            this.$track(
              trackingOpts.category || 'component',
              trackingOpts.action || 'mount',
              trackingOpts.label || this.$options.name || '',
              0,
              trackingOpts.data
            );
          }
        }
      },
      beforeDestroy: function() {
        if (this.$options.tracking && this.$options.tracking.onUnmount) {
          this.$track(
            this.$options.tracking.category || 'component',
            this.$options.tracking.action || 'unmount',
            this.$options.tracking.label || this.$options.name || '',
            0,
            this.$options.tracking.data
          );
        }
      }
    });
    
    log('Vue 2.x 支持已启用');
  }
  
  // Vue 3.x 支持
  function setupVue3Support() {
    // Vue 3.x 需要通过app实例注入
    log('Vue 3.x 检测到，需要在应用初始化时手动注入（待实现）');
  }
  
  // ElementUI 支持
  function setupElementUISupport() {
    log('ElementUI支持已启用');
    
    // ElementUI组件会自动渲染为DOM，通过data-track属性可以自动追踪
    // 这里主要是确保ElementUI渲染的元素也能被MutationObserver捕获
  }
  
  // 页面卸载时使用Beacon
  window.addEventListener('beforeunload', function() {
    if (config.useBeaconOnUnload && trackingState.isInitialized) {
      // 发送待发送的数据
      if (trackingState.pendingData.length > 0) {
        flushBatch();
      }
      
      // 发送页面卸载事件
      trackPageView({
        event: 'page_unload',
        timestamp: new Date().toISOString()
      }, {
        method: 'beacon',
        useBeacon: true,
        skipFrequencyCheck: true,
        forceImmediate: true
      });
    }
  });

  // 公开API
  window.DevOpsBITracker = {
    // 手动跟踪页面访问（智能降级）
    trackPageView: function(customData, options) {
      if (!trackingState.isInitialized) {
        log('错误: 埋点脚本未初始化');
        return false;
      }
      
      return trackPageView(customData, extendObject({ method: 'auto' }, options || {}));
    },
    
    // 使用 Fetch API 发送数据
    trackWithFetch: function(customData) {
      if (!trackingState.isInitialized) {
        log('错误: 埋点脚本未初始化');
        return false;
      }
      
      return trackPageView(customData, { method: 'fetch' });
    },
    
    // 使用 SendBeacon API 发送数据
    trackWithBeacon: function(customData) {
      if (!trackingState.isInitialized) {
        log('错误: 埋点脚本未初始化');
        return false;
      }
      
      return trackPageView(customData, { method: 'beacon', useBeacon: true });
    },
    
    // 手动跟踪事件
    trackEvent: function(category, action, label, value, customData) {
      var eventData = {
        category: category || '',
        action: action || '',
        label: label || '',
        value: value || 0
      };
      
      log('跟踪事件: ' + category + ' / ' + action);
      
      var custom = extendObject({ event: eventData }, customData || {});
      return this.trackPageView(custom);
    },
    
    // 手动跟踪自定义数据
    trackCustomData: function(customData) {
      log('跟踪自定义数据');
      return this.trackPageView(customData);
    },
    
    // 一键发送所有方式的数据（用于测试）
    trackAll: function(customData) {
      log('开始使用所有方式发送数据...');
      
      var results = {
        image: this.trackPageView(customData),
        fetch: this.trackWithFetch(customData),
        beacon: this.trackWithBeacon(customData)
      };
      
      log('发送结果:', results);
      return results;
    },
    
    // 获取配置
    getConfig: function() {
      return {
        trackingId: trackingId,
        sessionId: sessionId,
        apiUrl: apiUrl,
        config: config,
        state: trackingState
      };
    },
    
    // 更新配置
    updateConfig: function(newConfig) {
      extendObject(config, newConfig);
      log('配置已更新: ' + JSON.stringify(newConfig));
    },
    
    // 检查脚本状态
    isReady: function() {
      return trackingState.isInitialized;
    },
    
    // 新增：刷新批量数据（立即发送待发送的数据）
    flushBatch: function() {
      flushBatch();
    },
    
    // 新增：启用/禁用无侵入式跟踪
    enableAutoTracking: function(enabled) {
      config.enableAutoTracking = enabled;
      if (enabled && !trackingState.mutationObserver) {
        setupAutoTracking();
      } else if (!enabled && trackingState.mutationObserver) {
        trackingState.mutationObserver.disconnect();
        trackingState.mutationObserver = null;
      }
      log('无侵入式跟踪已' + (enabled ? '启用' : '禁用'));
    }
  };
  
  // 当DOM加载完成后初始化
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
  } else {
    init();
  }
})(); 